﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using NiSis.Entities;
using NiSis.Data;
using NiSis.Data.Bases;

#endregion

namespace NiSis.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("NiSis.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.8.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				// use default ConnectionStrings if _section has already been discovered
				if ( _config == null && _section != null )
				{
					return WebConfigurationManager.ConnectionStrings;
				}
				
				return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			public ConnectionProvider(String connectionStringName)
			{
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region SshComuniProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshComuni"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshComuniProviderBase SshComuniProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshComuniProvider;
			}
		}
		
		#endregion
		
		#region SshTipologiaSocietaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshTipologiaSocieta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshTipologiaSocietaProviderBase SshTipologiaSocietaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshTipologiaSocietaProvider;
			}
		}
		
		#endregion
		
		#region SshTraderPrecStoricoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshTraderPrecStorico"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshTraderPrecStoricoProviderBase SshTraderPrecStoricoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshTraderPrecStoricoProvider;
			}
		}
		
		#endregion
		
		#region SshPeriodiFornituraProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshPeriodiFornitura"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshPeriodiFornituraProviderBase SshPeriodiFornituraProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshPeriodiFornituraProvider;
			}
		}
		
		#endregion
		
		#region SshRelazioniSocietarieProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshRelazioniSocietarie"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshRelazioniSocietarieProviderBase SshRelazioniSocietarieProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshRelazioniSocietarieProvider;
			}
		}
		
		#endregion
		
		#region SshBatchRelazioniProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshBatchRelazioni"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshBatchRelazioniProviderBase SshBatchRelazioniProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshBatchRelazioniProvider;
			}
		}
		
		#endregion
		
		#region SshPoolStateProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshPoolState"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshPoolStateProviderBase SshPoolStateProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshPoolStateProvider;
			}
		}
		
		#endregion
		
		#region SshUtenzeGasStoricoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshUtenzeGasStorico"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshUtenzeGasStoricoProviderBase SshUtenzeGasStoricoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshUtenzeGasStoricoProvider;
			}
		}
		
		#endregion
		
		#region SshShipperAttiviSuPoolProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshShipperAttiviSuPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshShipperAttiviSuPoolProviderBase SshShipperAttiviSuPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshShipperAttiviSuPoolProvider;
			}
		}
		
		#endregion
		
		#region SshStatoRelazioniProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshStatoRelazioni"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshStatoRelazioniProviderBase SshStatoRelazioniProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshStatoRelazioniProvider;
			}
		}
		
		#endregion
		
		#region SshSocietaStoricoChainProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshSocietaStoricoChain"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshSocietaStoricoChainProviderBase SshSocietaStoricoChainProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshSocietaStoricoChainProvider;
			}
		}
		
		#endregion
		
		#region SshUtenzeGasProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshUtenzeGas"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshUtenzeGasProviderBase SshUtenzeGasProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshUtenzeGasProvider;
			}
		}
		
		#endregion
		
		#region SshNewSocietaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshNewSocieta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshNewSocietaProviderBase SshNewSocietaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshNewSocietaProvider;
			}
		}
		
		#endregion
		
		#region SshTipologPrelievoAeegProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshTipologPrelievoAeeg"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshTipologPrelievoAeegProviderBase SshTipologPrelievoAeegProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshTipologPrelievoAeegProvider;
			}
		}
		
		#endregion
		
		#region SshPoolProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshPoolProviderBase SshPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshPoolProvider;
			}
		}
		
		#endregion
		
		#region SshNewRelazioniSocietarieProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshNewRelazioniSocietarie"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshNewRelazioniSocietarieProviderBase SshNewRelazioniSocietarieProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshNewRelazioniSocietarieProvider;
			}
		}
		
		#endregion
		
		#region SshSocietaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SshSocieta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SshSocietaProviderBase SshSocietaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SshSocietaProvider;
			}
		}
		
		#endregion
		
		
		#region VAllShippersProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VAllShippers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VAllShippersProviderBase VAllShippersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VAllShippersProvider;
			}
		}
		
		#endregion
		
		#region VBatchTraderPrecProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VBatchTraderPrec"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VBatchTraderPrecProviderBase VBatchTraderPrecProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VBatchTraderPrecProvider;
			}
		}
		
		#endregion
		
		#region VBatchTraderPrecStProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VBatchTraderPrecSt"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VBatchTraderPrecStProviderBase VBatchTraderPrecStProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VBatchTraderPrecStProvider;
			}
		}
		
		#endregion
		
		#region VBatchTraderPrecStPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VBatchTraderPrecStPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VBatchTraderPrecStPoolProviderBase VBatchTraderPrecStPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VBatchTraderPrecStPoolProvider;
			}
		}
		
		#endregion
		
		#region VBatchUtenzeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VBatchUtenze"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VBatchUtenzeProviderBase VBatchUtenzeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VBatchUtenzeProvider;
			}
		}
		
		#endregion
		
		#region VCdMeseProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VCdMese"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VCdMeseProviderBase VCdMeseProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VCdMeseProvider;
			}
		}
		
		#endregion
		
		#region VCdMeseAllProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VCdMeseAll"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VCdMeseAllProviderBase VCdMeseAllProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VCdMeseAllProvider;
			}
		}
		
		#endregion
		
		#region VConsolidaUtenzeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VConsolidaUtenze"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VConsolidaUtenzeProviderBase VConsolidaUtenzeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VConsolidaUtenzeProvider;
			}
		}
		
		#endregion
		
		#region VIntersecRelazioniSocietarieProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VIntersecRelazioniSocietarie"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VIntersecRelazioniSocietarieProviderBase VIntersecRelazioniSocietarieProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VIntersecRelazioniSocietarieProvider;
			}
		}
		
		#endregion
		
		#region VIntersecShipperAttiviPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VIntersecShipperAttiviPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VIntersecShipperAttiviPoolProviderBase VIntersecShipperAttiviPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VIntersecShipperAttiviPoolProvider;
			}
		}
		
		#endregion
		
		#region VIntersecShipperFilterProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VIntersecShipperFilter"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VIntersecShipperFilterProviderBase VIntersecShipperFilterProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VIntersecShipperFilterProvider;
			}
		}
		
		#endregion
		
		#region VNewRelazioniSocietarieProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VNewRelazioniSocietarie"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VNewRelazioniSocietarieProviderBase VNewRelazioniSocietarieProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VNewRelazioniSocietarieProvider;
			}
		}
		
		#endregion
		
		#region VNewSocietaProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VNewSocieta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VNewSocietaProviderBase VNewSocietaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VNewSocietaProvider;
			}
		}
		
		#endregion
		
		#region VPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VPoolProviderBase VPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VPoolProvider;
			}
		}
		
		#endregion
		
		#region VRejectedShippersProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VRejectedShippers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VRejectedShippersProviderBase VRejectedShippersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VRejectedShippersProvider;
			}
		}
		
		#endregion
		
		#region VRelazioniSocietarieProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VRelazioniSocietarie"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VRelazioniSocietarieProviderBase VRelazioniSocietarieProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VRelazioniSocietarieProvider;
			}
		}
		
		#endregion
		
		#region VReportProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VReport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VReportProviderBase VReportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VReportProvider;
			}
		}
		
		#endregion
		
		#region VShipperAttiviPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VShipperAttiviPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VShipperAttiviPoolProviderBase VShipperAttiviPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VShipperAttiviPoolProvider;
			}
		}
		
		#endregion
		
		#region VShipperDefaultPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VShipperDefaultPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VShipperDefaultPoolProviderBase VShipperDefaultPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VShipperDefaultPoolProvider;
			}
		}
		
		#endregion
		
		#region VSimpleShipperDefaultPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VSimpleShipperDefaultPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VSimpleShipperDefaultPoolProviderBase VSimpleShipperDefaultPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VSimpleShipperDefaultPoolProvider;
			}
		}
		
		#endregion
		
		#region VSimpleShipperFilterProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VSimpleShipperFilter"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VSimpleShipperFilterProviderBase VSimpleShipperFilterProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VSimpleShipperFilterProvider;
			}
		}
		
		#endregion
		
		#region VSimpleTraderPrecProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VSimpleTraderPrec"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VSimpleTraderPrecProviderBase VSimpleTraderPrecProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VSimpleTraderPrecProvider;
			}
		}
		
		#endregion
		
		#region VSocietaAllProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VSocietaAll"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VSocietaAllProviderBase VSocietaAllProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VSocietaAllProvider;
			}
		}
		
		#endregion
		
		#region VSocietaStoricoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VSocietaStorico"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VSocietaStoricoProviderBase VSocietaStoricoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VSocietaStoricoProvider;
			}
		}
		
		#endregion
		
		#region VTpPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTpPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTpPoolProviderBase VTpPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTpPoolProvider;
			}
		}
		
		#endregion
		
		#region VTpUtenzeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTpUtenze"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTpUtenzeProviderBase VTpUtenzeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTpUtenzeProvider;
			}
		}
		
		#endregion
		
		#region VTpUtenzeAllProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTpUtenzeAll"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTpUtenzeAllProviderBase VTpUtenzeAllProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTpUtenzeAllProvider;
			}
		}
		
		#endregion
		
		#region VTputenzePoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTputenzePool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTputenzePoolProviderBase VTputenzePoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTputenzePoolProvider;
			}
		}
		
		#endregion
		
		#region VTpUtenzeStoricoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTpUtenzeStorico"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTpUtenzeStoricoProviderBase VTpUtenzeStoricoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTpUtenzeStoricoProvider;
			}
		}
		
		#endregion
		
		#region VTraderInRelationshipProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTraderInRelationship"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTraderInRelationshipProviderBase VTraderInRelationshipProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTraderInRelationshipProvider;
			}
		}
		
		#endregion
		
		#region VTradersPrecProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VTradersPrec"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VTradersPrecProviderBase VTradersPrecProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VTradersPrecProvider;
			}
		}
		
		#endregion
		
		#region VUtenzeInPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VUtenzeInPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VUtenzeInPoolProviderBase VUtenzeInPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VUtenzeInPoolProvider;
			}
		}
		
		#endregion
		
		#region VUtenzeNotInPoolProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VUtenzeNotInPool"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VUtenzeNotInPoolProviderBase VUtenzeNotInPoolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VUtenzeNotInPoolProvider;
			}
		}
		
		#endregion
		
		#region VUtenzePoolNonDefinitoProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VUtenzePoolNonDefinito"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VUtenzePoolNonDefinitoProviderBase VUtenzePoolNonDefinitoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VUtenzePoolNonDefinitoProvider;
			}
		}
		
		#endregion
		
		#endregion
	}
	
	#region Query/Filters
		
	#region SshComuniFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshComuni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshComuniFilters : SshComuniFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshComuniFilters class.
		/// </summary>
		public SshComuniFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshComuniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshComuniFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshComuniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshComuniFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshComuniFilters
	
	#region SshComuniQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshComuniParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshComuni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshComuniQuery : SshComuniParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshComuniQuery class.
		/// </summary>
		public SshComuniQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshComuniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshComuniQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshComuniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshComuniQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshComuniQuery
		
	#region SshTipologiaSocietaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshTipologiaSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTipologiaSocietaFilters : SshTipologiaSocietaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaFilters class.
		/// </summary>
		public SshTipologiaSocietaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTipologiaSocietaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTipologiaSocietaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTipologiaSocietaFilters
	
	#region SshTipologiaSocietaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshTipologiaSocietaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshTipologiaSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTipologiaSocietaQuery : SshTipologiaSocietaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaQuery class.
		/// </summary>
		public SshTipologiaSocietaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTipologiaSocietaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTipologiaSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTipologiaSocietaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTipologiaSocietaQuery
		
	#region SshTraderPrecStoricoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshTraderPrecStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTraderPrecStoricoFilters : SshTraderPrecStoricoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoFilters class.
		/// </summary>
		public SshTraderPrecStoricoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTraderPrecStoricoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTraderPrecStoricoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTraderPrecStoricoFilters
	
	#region SshTraderPrecStoricoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshTraderPrecStoricoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshTraderPrecStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTraderPrecStoricoQuery : SshTraderPrecStoricoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoQuery class.
		/// </summary>
		public SshTraderPrecStoricoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTraderPrecStoricoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTraderPrecStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTraderPrecStoricoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTraderPrecStoricoQuery
		
	#region SshPeriodiFornituraFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshPeriodiFornitura"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPeriodiFornituraFilters : SshPeriodiFornituraFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraFilters class.
		/// </summary>
		public SshPeriodiFornituraFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPeriodiFornituraFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPeriodiFornituraFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPeriodiFornituraFilters
	
	#region SshPeriodiFornituraQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshPeriodiFornituraParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshPeriodiFornitura"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPeriodiFornituraQuery : SshPeriodiFornituraParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraQuery class.
		/// </summary>
		public SshPeriodiFornituraQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPeriodiFornituraQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPeriodiFornituraQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPeriodiFornituraQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPeriodiFornituraQuery
		
	#region SshRelazioniSocietarieFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshRelazioniSocietarieFilters : SshRelazioniSocietarieFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieFilters class.
		/// </summary>
		public SshRelazioniSocietarieFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshRelazioniSocietarieFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshRelazioniSocietarieFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshRelazioniSocietarieFilters
	
	#region SshRelazioniSocietarieQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshRelazioniSocietarieParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshRelazioniSocietarieQuery : SshRelazioniSocietarieParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieQuery class.
		/// </summary>
		public SshRelazioniSocietarieQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshRelazioniSocietarieQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshRelazioniSocietarieQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshRelazioniSocietarieQuery
		
	#region SshBatchRelazioniFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshBatchRelazioni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshBatchRelazioniFilters : SshBatchRelazioniFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniFilters class.
		/// </summary>
		public SshBatchRelazioniFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshBatchRelazioniFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshBatchRelazioniFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshBatchRelazioniFilters
	
	#region SshBatchRelazioniQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshBatchRelazioniParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshBatchRelazioni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshBatchRelazioniQuery : SshBatchRelazioniParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniQuery class.
		/// </summary>
		public SshBatchRelazioniQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshBatchRelazioniQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshBatchRelazioniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshBatchRelazioniQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshBatchRelazioniQuery
		
	#region SshPoolStateFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshPoolState"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPoolStateFilters : SshPoolStateFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPoolStateFilters class.
		/// </summary>
		public SshPoolStateFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPoolStateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPoolStateFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPoolStateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPoolStateFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPoolStateFilters
	
	#region SshPoolStateQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshPoolStateParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshPoolState"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPoolStateQuery : SshPoolStateParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPoolStateQuery class.
		/// </summary>
		public SshPoolStateQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPoolStateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPoolStateQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPoolStateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPoolStateQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPoolStateQuery
		
	#region SshUtenzeGasStoricoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshUtenzeGasStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshUtenzeGasStoricoFilters : SshUtenzeGasStoricoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoFilters class.
		/// </summary>
		public SshUtenzeGasStoricoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshUtenzeGasStoricoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshUtenzeGasStoricoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshUtenzeGasStoricoFilters
	
	#region SshUtenzeGasStoricoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshUtenzeGasStoricoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshUtenzeGasStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshUtenzeGasStoricoQuery : SshUtenzeGasStoricoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoQuery class.
		/// </summary>
		public SshUtenzeGasStoricoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshUtenzeGasStoricoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshUtenzeGasStoricoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshUtenzeGasStoricoQuery
		
	#region SshShipperAttiviSuPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshShipperAttiviSuPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshShipperAttiviSuPoolFilters : SshShipperAttiviSuPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolFilters class.
		/// </summary>
		public SshShipperAttiviSuPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshShipperAttiviSuPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshShipperAttiviSuPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshShipperAttiviSuPoolFilters
	
	#region SshShipperAttiviSuPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshShipperAttiviSuPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshShipperAttiviSuPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshShipperAttiviSuPoolQuery : SshShipperAttiviSuPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolQuery class.
		/// </summary>
		public SshShipperAttiviSuPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshShipperAttiviSuPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshShipperAttiviSuPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshShipperAttiviSuPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshShipperAttiviSuPoolQuery
		
	#region SshStatoRelazioniFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshStatoRelazioni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshStatoRelazioniFilters : SshStatoRelazioniFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniFilters class.
		/// </summary>
		public SshStatoRelazioniFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshStatoRelazioniFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshStatoRelazioniFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshStatoRelazioniFilters
	
	#region SshStatoRelazioniQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshStatoRelazioniParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshStatoRelazioni"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshStatoRelazioniQuery : SshStatoRelazioniParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniQuery class.
		/// </summary>
		public SshStatoRelazioniQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshStatoRelazioniQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshStatoRelazioniQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshStatoRelazioniQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshStatoRelazioniQuery
		
	#region SshSocietaStoricoChainFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshSocietaStoricoChain"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshSocietaStoricoChainFilters : SshSocietaStoricoChainFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainFilters class.
		/// </summary>
		public SshSocietaStoricoChainFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshSocietaStoricoChainFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshSocietaStoricoChainFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshSocietaStoricoChainFilters
	
	#region SshSocietaStoricoChainQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshSocietaStoricoChainParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshSocietaStoricoChain"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshSocietaStoricoChainQuery : SshSocietaStoricoChainParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainQuery class.
		/// </summary>
		public SshSocietaStoricoChainQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshSocietaStoricoChainQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaStoricoChainQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshSocietaStoricoChainQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshSocietaStoricoChainQuery
		
	#region SshUtenzeGasFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshUtenzeGas"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshUtenzeGasFilters : SshUtenzeGasFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasFilters class.
		/// </summary>
		public SshUtenzeGasFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshUtenzeGasFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshUtenzeGasFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshUtenzeGasFilters
	
	#region SshUtenzeGasQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshUtenzeGasParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshUtenzeGas"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshUtenzeGasQuery : SshUtenzeGasParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasQuery class.
		/// </summary>
		public SshUtenzeGasQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshUtenzeGasQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshUtenzeGasQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshUtenzeGasQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshUtenzeGasQuery
		
	#region SshNewSocietaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshNewSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshNewSocietaFilters : SshNewSocietaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaFilters class.
		/// </summary>
		public SshNewSocietaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshNewSocietaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshNewSocietaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshNewSocietaFilters
	
	#region SshNewSocietaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshNewSocietaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshNewSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshNewSocietaQuery : SshNewSocietaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaQuery class.
		/// </summary>
		public SshNewSocietaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshNewSocietaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshNewSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshNewSocietaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshNewSocietaQuery
		
	#region SshTipologPrelievoAeegFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshTipologPrelievoAeeg"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTipologPrelievoAeegFilters : SshTipologPrelievoAeegFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegFilters class.
		/// </summary>
		public SshTipologPrelievoAeegFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTipologPrelievoAeegFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTipologPrelievoAeegFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTipologPrelievoAeegFilters
	
	#region SshTipologPrelievoAeegQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshTipologPrelievoAeegParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshTipologPrelievoAeeg"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshTipologPrelievoAeegQuery : SshTipologPrelievoAeegParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegQuery class.
		/// </summary>
		public SshTipologPrelievoAeegQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshTipologPrelievoAeegQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshTipologPrelievoAeegQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshTipologPrelievoAeegQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshTipologPrelievoAeegQuery
		
	#region SshPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPoolFilters : SshPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPoolFilters class.
		/// </summary>
		public SshPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPoolFilters
	
	#region SshPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshPoolQuery : SshPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshPoolQuery class.
		/// </summary>
		public SshPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshPoolQuery
		
	#region SshNewRelazioniSocietarieFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshNewRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshNewRelazioniSocietarieFilters : SshNewRelazioniSocietarieFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieFilters class.
		/// </summary>
		public SshNewRelazioniSocietarieFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshNewRelazioniSocietarieFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshNewRelazioniSocietarieFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshNewRelazioniSocietarieFilters
	
	#region SshNewRelazioniSocietarieQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshNewRelazioniSocietarieParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshNewRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshNewRelazioniSocietarieQuery : SshNewRelazioniSocietarieParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieQuery class.
		/// </summary>
		public SshNewRelazioniSocietarieQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshNewRelazioniSocietarieQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshNewRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshNewRelazioniSocietarieQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshNewRelazioniSocietarieQuery
		
	#region SshSocietaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SshSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshSocietaFilters : SshSocietaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshSocietaFilters class.
		/// </summary>
		public SshSocietaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshSocietaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshSocietaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshSocietaFilters
	
	#region SshSocietaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SshSocietaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SshSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SshSocietaQuery : SshSocietaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SshSocietaQuery class.
		/// </summary>
		public SshSocietaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SshSocietaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SshSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SshSocietaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SshSocietaQuery
		
	#region VAllShippersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VAllShippers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VAllShippersFilters : VAllShippersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VAllShippersFilters class.
		/// </summary>
		public VAllShippersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VAllShippersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VAllShippersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VAllShippersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VAllShippersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VAllShippersFilters
	
	#region VAllShippersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VAllShippersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VAllShippers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VAllShippersQuery : VAllShippersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VAllShippersQuery class.
		/// </summary>
		public VAllShippersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VAllShippersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VAllShippersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VAllShippersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VAllShippersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VAllShippersQuery
		
	#region VBatchTraderPrecFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecFilters : VBatchTraderPrecFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecFilters class.
		/// </summary>
		public VBatchTraderPrecFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecFilters
	
	#region VBatchTraderPrecQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VBatchTraderPrecParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecQuery : VBatchTraderPrecParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecQuery class.
		/// </summary>
		public VBatchTraderPrecQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecQuery
		
	#region VBatchTraderPrecStFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrecSt"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecStFilters : VBatchTraderPrecStFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStFilters class.
		/// </summary>
		public VBatchTraderPrecStFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecStFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecStFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecStFilters
	
	#region VBatchTraderPrecStQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VBatchTraderPrecStParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrecSt"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecStQuery : VBatchTraderPrecStParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStQuery class.
		/// </summary>
		public VBatchTraderPrecStQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecStQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecStQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecStQuery
		
	#region VBatchTraderPrecStPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrecStPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecStPoolFilters : VBatchTraderPrecStPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolFilters class.
		/// </summary>
		public VBatchTraderPrecStPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecStPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecStPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecStPoolFilters
	
	#region VBatchTraderPrecStPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VBatchTraderPrecStPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VBatchTraderPrecStPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchTraderPrecStPoolQuery : VBatchTraderPrecStPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolQuery class.
		/// </summary>
		public VBatchTraderPrecStPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchTraderPrecStPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchTraderPrecStPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchTraderPrecStPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchTraderPrecStPoolQuery
		
	#region VBatchUtenzeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VBatchUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchUtenzeFilters : VBatchUtenzeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeFilters class.
		/// </summary>
		public VBatchUtenzeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchUtenzeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchUtenzeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchUtenzeFilters
	
	#region VBatchUtenzeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VBatchUtenzeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VBatchUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VBatchUtenzeQuery : VBatchUtenzeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeQuery class.
		/// </summary>
		public VBatchUtenzeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VBatchUtenzeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VBatchUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VBatchUtenzeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VBatchUtenzeQuery
		
	#region VCdMeseFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VCdMese"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VCdMeseFilters : VCdMeseFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VCdMeseFilters class.
		/// </summary>
		public VCdMeseFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VCdMeseFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VCdMeseFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VCdMeseFilters
	
	#region VCdMeseQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VCdMeseParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VCdMese"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VCdMeseQuery : VCdMeseParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VCdMeseQuery class.
		/// </summary>
		public VCdMeseQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VCdMeseQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VCdMeseQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VCdMeseQuery
		
	#region VCdMeseAllFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VCdMeseAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VCdMeseAllFilters : VCdMeseAllFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllFilters class.
		/// </summary>
		public VCdMeseAllFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VCdMeseAllFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VCdMeseAllFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VCdMeseAllFilters
	
	#region VCdMeseAllQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VCdMeseAllParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VCdMeseAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VCdMeseAllQuery : VCdMeseAllParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllQuery class.
		/// </summary>
		public VCdMeseAllQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VCdMeseAllQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VCdMeseAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VCdMeseAllQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VCdMeseAllQuery
		
	#region VConsolidaUtenzeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VConsolidaUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VConsolidaUtenzeFilters : VConsolidaUtenzeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeFilters class.
		/// </summary>
		public VConsolidaUtenzeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VConsolidaUtenzeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VConsolidaUtenzeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VConsolidaUtenzeFilters
	
	#region VConsolidaUtenzeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VConsolidaUtenzeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VConsolidaUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VConsolidaUtenzeQuery : VConsolidaUtenzeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeQuery class.
		/// </summary>
		public VConsolidaUtenzeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VConsolidaUtenzeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VConsolidaUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VConsolidaUtenzeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VConsolidaUtenzeQuery
		
	#region VIntersecRelazioniSocietarieFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VIntersecRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecRelazioniSocietarieFilters : VIntersecRelazioniSocietarieFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieFilters class.
		/// </summary>
		public VIntersecRelazioniSocietarieFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecRelazioniSocietarieFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecRelazioniSocietarieFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecRelazioniSocietarieFilters
	
	#region VIntersecRelazioniSocietarieQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VIntersecRelazioniSocietarieParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VIntersecRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecRelazioniSocietarieQuery : VIntersecRelazioniSocietarieParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieQuery class.
		/// </summary>
		public VIntersecRelazioniSocietarieQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecRelazioniSocietarieQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecRelazioniSocietarieQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecRelazioniSocietarieQuery
		
	#region VIntersecShipperAttiviPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VIntersecShipperAttiviPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecShipperAttiviPoolFilters : VIntersecShipperAttiviPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolFilters class.
		/// </summary>
		public VIntersecShipperAttiviPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecShipperAttiviPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecShipperAttiviPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecShipperAttiviPoolFilters
	
	#region VIntersecShipperAttiviPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VIntersecShipperAttiviPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VIntersecShipperAttiviPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecShipperAttiviPoolQuery : VIntersecShipperAttiviPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolQuery class.
		/// </summary>
		public VIntersecShipperAttiviPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecShipperAttiviPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperAttiviPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecShipperAttiviPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecShipperAttiviPoolQuery
		
	#region VIntersecShipperFilterFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VIntersecShipperFilter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecShipperFilterFilters : VIntersecShipperFilterFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterFilters class.
		/// </summary>
		public VIntersecShipperFilterFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecShipperFilterFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecShipperFilterFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecShipperFilterFilters
	
	#region VIntersecShipperFilterQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VIntersecShipperFilterParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VIntersecShipperFilter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VIntersecShipperFilterQuery : VIntersecShipperFilterParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterQuery class.
		/// </summary>
		public VIntersecShipperFilterQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VIntersecShipperFilterQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VIntersecShipperFilterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VIntersecShipperFilterQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VIntersecShipperFilterQuery
		
	#region VNewRelazioniSocietarieFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VNewRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VNewRelazioniSocietarieFilters : VNewRelazioniSocietarieFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieFilters class.
		/// </summary>
		public VNewRelazioniSocietarieFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VNewRelazioniSocietarieFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VNewRelazioniSocietarieFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VNewRelazioniSocietarieFilters
	
	#region VNewRelazioniSocietarieQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VNewRelazioniSocietarieParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VNewRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VNewRelazioniSocietarieQuery : VNewRelazioniSocietarieParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieQuery class.
		/// </summary>
		public VNewRelazioniSocietarieQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VNewRelazioniSocietarieQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VNewRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VNewRelazioniSocietarieQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VNewRelazioniSocietarieQuery
		
	#region VNewSocietaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VNewSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VNewSocietaFilters : VNewSocietaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VNewSocietaFilters class.
		/// </summary>
		public VNewSocietaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VNewSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VNewSocietaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VNewSocietaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VNewSocietaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VNewSocietaFilters
	
	#region VNewSocietaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VNewSocietaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VNewSocieta"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VNewSocietaQuery : VNewSocietaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VNewSocietaQuery class.
		/// </summary>
		public VNewSocietaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VNewSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VNewSocietaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VNewSocietaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VNewSocietaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VNewSocietaQuery
		
	#region VPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VPoolFilters : VPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VPoolFilters class.
		/// </summary>
		public VPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VPoolFilters
	
	#region VPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VPoolQuery : VPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VPoolQuery class.
		/// </summary>
		public VPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VPoolQuery
		
	#region VRejectedShippersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VRejectedShippers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VRejectedShippersFilters : VRejectedShippersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersFilters class.
		/// </summary>
		public VRejectedShippersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VRejectedShippersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VRejectedShippersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VRejectedShippersFilters
	
	#region VRejectedShippersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VRejectedShippersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VRejectedShippers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VRejectedShippersQuery : VRejectedShippersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersQuery class.
		/// </summary>
		public VRejectedShippersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VRejectedShippersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VRejectedShippersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VRejectedShippersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VRejectedShippersQuery
		
	#region VRelazioniSocietarieFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VRelazioniSocietarieFilters : VRelazioniSocietarieFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieFilters class.
		/// </summary>
		public VRelazioniSocietarieFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VRelazioniSocietarieFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VRelazioniSocietarieFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VRelazioniSocietarieFilters
	
	#region VRelazioniSocietarieQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VRelazioniSocietarieParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VRelazioniSocietarie"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VRelazioniSocietarieQuery : VRelazioniSocietarieParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieQuery class.
		/// </summary>
		public VRelazioniSocietarieQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VRelazioniSocietarieQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VRelazioniSocietarieQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VRelazioniSocietarieQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VRelazioniSocietarieQuery
		
	#region VReportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VReportFilters : VReportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VReportFilters class.
		/// </summary>
		public VReportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VReportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VReportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VReportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VReportFilters
	
	#region VReportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VReportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VReport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VReportQuery : VReportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VReportQuery class.
		/// </summary>
		public VReportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VReportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VReportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VReportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VReportQuery
		
	#region VShipperAttiviPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VShipperAttiviPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VShipperAttiviPoolFilters : VShipperAttiviPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolFilters class.
		/// </summary>
		public VShipperAttiviPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VShipperAttiviPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VShipperAttiviPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VShipperAttiviPoolFilters
	
	#region VShipperAttiviPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VShipperAttiviPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VShipperAttiviPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VShipperAttiviPoolQuery : VShipperAttiviPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolQuery class.
		/// </summary>
		public VShipperAttiviPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VShipperAttiviPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VShipperAttiviPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VShipperAttiviPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VShipperAttiviPoolQuery
		
	#region VShipperDefaultPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VShipperDefaultPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VShipperDefaultPoolFilters : VShipperDefaultPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolFilters class.
		/// </summary>
		public VShipperDefaultPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VShipperDefaultPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VShipperDefaultPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VShipperDefaultPoolFilters
	
	#region VShipperDefaultPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VShipperDefaultPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VShipperDefaultPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VShipperDefaultPoolQuery : VShipperDefaultPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolQuery class.
		/// </summary>
		public VShipperDefaultPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VShipperDefaultPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VShipperDefaultPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VShipperDefaultPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VShipperDefaultPoolQuery
		
	#region VSimpleShipperDefaultPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VSimpleShipperDefaultPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleShipperDefaultPoolFilters : VSimpleShipperDefaultPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolFilters class.
		/// </summary>
		public VSimpleShipperDefaultPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleShipperDefaultPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleShipperDefaultPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleShipperDefaultPoolFilters
	
	#region VSimpleShipperDefaultPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VSimpleShipperDefaultPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VSimpleShipperDefaultPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleShipperDefaultPoolQuery : VSimpleShipperDefaultPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolQuery class.
		/// </summary>
		public VSimpleShipperDefaultPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleShipperDefaultPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperDefaultPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleShipperDefaultPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleShipperDefaultPoolQuery
		
	#region VSimpleShipperFilterFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VSimpleShipperFilter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleShipperFilterFilters : VSimpleShipperFilterFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterFilters class.
		/// </summary>
		public VSimpleShipperFilterFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleShipperFilterFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleShipperFilterFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleShipperFilterFilters
	
	#region VSimpleShipperFilterQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VSimpleShipperFilterParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VSimpleShipperFilter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleShipperFilterQuery : VSimpleShipperFilterParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterQuery class.
		/// </summary>
		public VSimpleShipperFilterQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleShipperFilterQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleShipperFilterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleShipperFilterQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleShipperFilterQuery
		
	#region VSimpleTraderPrecFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VSimpleTraderPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleTraderPrecFilters : VSimpleTraderPrecFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecFilters class.
		/// </summary>
		public VSimpleTraderPrecFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleTraderPrecFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleTraderPrecFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleTraderPrecFilters
	
	#region VSimpleTraderPrecQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VSimpleTraderPrecParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VSimpleTraderPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSimpleTraderPrecQuery : VSimpleTraderPrecParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecQuery class.
		/// </summary>
		public VSimpleTraderPrecQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSimpleTraderPrecQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSimpleTraderPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSimpleTraderPrecQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSimpleTraderPrecQuery
		
	#region VSocietaAllFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VSocietaAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSocietaAllFilters : VSocietaAllFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSocietaAllFilters class.
		/// </summary>
		public VSocietaAllFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSocietaAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSocietaAllFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSocietaAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSocietaAllFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSocietaAllFilters
	
	#region VSocietaAllQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VSocietaAllParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VSocietaAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSocietaAllQuery : VSocietaAllParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSocietaAllQuery class.
		/// </summary>
		public VSocietaAllQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSocietaAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSocietaAllQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSocietaAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSocietaAllQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSocietaAllQuery
		
	#region VSocietaStoricoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VSocietaStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSocietaStoricoFilters : VSocietaStoricoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoFilters class.
		/// </summary>
		public VSocietaStoricoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSocietaStoricoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSocietaStoricoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSocietaStoricoFilters
	
	#region VSocietaStoricoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VSocietaStoricoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VSocietaStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VSocietaStoricoQuery : VSocietaStoricoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoQuery class.
		/// </summary>
		public VSocietaStoricoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VSocietaStoricoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VSocietaStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VSocietaStoricoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VSocietaStoricoQuery
		
	#region VTpPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTpPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpPoolFilters : VTpPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpPoolFilters class.
		/// </summary>
		public VTpPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpPoolFilters
	
	#region VTpPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTpPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTpPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpPoolQuery : VTpPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpPoolQuery class.
		/// </summary>
		public VTpPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpPoolQuery
		
	#region VTpUtenzeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTpUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeFilters : VTpUtenzeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeFilters class.
		/// </summary>
		public VTpUtenzeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeFilters
	
	#region VTpUtenzeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTpUtenzeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTpUtenze"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeQuery : VTpUtenzeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeQuery class.
		/// </summary>
		public VTpUtenzeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeQuery
		
	#region VTpUtenzeAllFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTpUtenzeAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeAllFilters : VTpUtenzeAllFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllFilters class.
		/// </summary>
		public VTpUtenzeAllFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeAllFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeAllFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeAllFilters
	
	#region VTpUtenzeAllQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTpUtenzeAllParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTpUtenzeAll"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeAllQuery : VTpUtenzeAllParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllQuery class.
		/// </summary>
		public VTpUtenzeAllQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeAllQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeAllQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeAllQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeAllQuery
		
	#region VTputenzePoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTputenzePool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTputenzePoolFilters : VTputenzePoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolFilters class.
		/// </summary>
		public VTputenzePoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTputenzePoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTputenzePoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTputenzePoolFilters
	
	#region VTputenzePoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTputenzePoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTputenzePool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTputenzePoolQuery : VTputenzePoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolQuery class.
		/// </summary>
		public VTputenzePoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTputenzePoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTputenzePoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTputenzePoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTputenzePoolQuery
		
	#region VTpUtenzeStoricoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTpUtenzeStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeStoricoFilters : VTpUtenzeStoricoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoFilters class.
		/// </summary>
		public VTpUtenzeStoricoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeStoricoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeStoricoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeStoricoFilters
	
	#region VTpUtenzeStoricoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTpUtenzeStoricoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTpUtenzeStorico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTpUtenzeStoricoQuery : VTpUtenzeStoricoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoQuery class.
		/// </summary>
		public VTpUtenzeStoricoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTpUtenzeStoricoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTpUtenzeStoricoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTpUtenzeStoricoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTpUtenzeStoricoQuery
		
	#region VTraderInRelationshipFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTraderInRelationship"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTraderInRelationshipFilters : VTraderInRelationshipFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipFilters class.
		/// </summary>
		public VTraderInRelationshipFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTraderInRelationshipFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTraderInRelationshipFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTraderInRelationshipFilters
	
	#region VTraderInRelationshipQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTraderInRelationshipParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTraderInRelationship"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTraderInRelationshipQuery : VTraderInRelationshipParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipQuery class.
		/// </summary>
		public VTraderInRelationshipQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTraderInRelationshipQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTraderInRelationshipQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTraderInRelationshipQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTraderInRelationshipQuery
		
	#region VTradersPrecFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VTradersPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTradersPrecFilters : VTradersPrecFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTradersPrecFilters class.
		/// </summary>
		public VTradersPrecFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTradersPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTradersPrecFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTradersPrecFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTradersPrecFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTradersPrecFilters
	
	#region VTradersPrecQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VTradersPrecParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VTradersPrec"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VTradersPrecQuery : VTradersPrecParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VTradersPrecQuery class.
		/// </summary>
		public VTradersPrecQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VTradersPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VTradersPrecQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VTradersPrecQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VTradersPrecQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VTradersPrecQuery
		
	#region VUtenzeInPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VUtenzeInPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzeInPoolFilters : VUtenzeInPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolFilters class.
		/// </summary>
		public VUtenzeInPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzeInPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzeInPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzeInPoolFilters
	
	#region VUtenzeInPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VUtenzeInPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VUtenzeInPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzeInPoolQuery : VUtenzeInPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolQuery class.
		/// </summary>
		public VUtenzeInPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzeInPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeInPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzeInPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzeInPoolQuery
		
	#region VUtenzeNotInPoolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VUtenzeNotInPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzeNotInPoolFilters : VUtenzeNotInPoolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolFilters class.
		/// </summary>
		public VUtenzeNotInPoolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzeNotInPoolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzeNotInPoolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzeNotInPoolFilters
	
	#region VUtenzeNotInPoolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VUtenzeNotInPoolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VUtenzeNotInPool"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzeNotInPoolQuery : VUtenzeNotInPoolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolQuery class.
		/// </summary>
		public VUtenzeNotInPoolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzeNotInPoolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzeNotInPoolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzeNotInPoolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzeNotInPoolQuery
		
	#region VUtenzePoolNonDefinitoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VUtenzePoolNonDefinito"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzePoolNonDefinitoFilters : VUtenzePoolNonDefinitoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoFilters class.
		/// </summary>
		public VUtenzePoolNonDefinitoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzePoolNonDefinitoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzePoolNonDefinitoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzePoolNonDefinitoFilters
	
	#region VUtenzePoolNonDefinitoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VUtenzePoolNonDefinitoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VUtenzePoolNonDefinito"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VUtenzePoolNonDefinitoQuery : VUtenzePoolNonDefinitoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoQuery class.
		/// </summary>
		public VUtenzePoolNonDefinitoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VUtenzePoolNonDefinitoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VUtenzePoolNonDefinitoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VUtenzePoolNonDefinitoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VUtenzePoolNonDefinitoQuery
	#endregion

	
}
